home *** CD-ROM | disk | FTP | other *** search
/ Aminet 41 / Aminet 41 (2001)(Schatztruhe)[!][Feb 2001].iso / Aminet / comm / misc / ClipWatch.lha / ClipWatch / Sources / serial-modem.c < prev    next >
Text File  |  2000-12-29  |  10KB  |  439 lines
  1. /*
  2.  
  3.      GESTION PORT SERIE / TRAMES
  4.      GESTION MODEM
  5.  
  6.      Marc Le Douarain , Décembre 1998
  7.      mavati@club-internet.fr
  8.      http://perso.club-internet.fr/mavati
  9.      http://www.multimania.com/mavati
  10.  
  11.      Dernière mise à jour : 29 décembre 2000 
  12.  
  13. */
  14.  
  15. void Mem_FreeAll(void);
  16.  
  17.  
  18. void Print_Monitor(char *chaine,int lgt,char mode,char direction)
  19. {
  20.  int i;
  21.  char car;
  22.  if (lgt>0)
  23.  {
  24.   if ((mode&2)==2)
  25.   {
  26.    if (direction==MONITOR_IN)
  27.    {
  28.     printf("<");
  29.    }
  30.    if (direction==MONITOR_OUT)
  31.    {
  32.     printf(">");
  33.    }
  34.    i=0;
  35.    {
  36.     do
  37.     {
  38.      printf("%x ",chaine[i]);
  39.      i++;
  40.     }while(i<lgt);
  41.     if (direction>0)
  42.     {
  43.      printf("\n");
  44.     }
  45.    }
  46.   }
  47.   if ((mode==0)||(mode==1)||(mode==3))
  48.   {
  49.    if (direction==MONITOR_IN)
  50.    {
  51.     printf("<");
  52.    }
  53.    if (direction==MONITOR_OUT)
  54.    {
  55.     printf(">");
  56.    }
  57.    i=0;
  58.    do
  59.    {
  60.     car=chaine[i];
  61.     switch(car)
  62.     {
  63.      case 9:
  64.       printf("[TAB]");
  65.       break;
  66.      case 13:
  67.       printf("[CR]");
  68.       break;
  69.      case 10:
  70.       printf("[LF]");
  71.       break;
  72.      case 27:
  73.       printf("[ESC]");
  74.       break;
  75.      case 0:
  76.       printf("[NULL]");
  77.       break;
  78.      default:
  79.       printf("%c",car);
  80.     }
  81.     i++;
  82.    }while(i<lgt);
  83.    if (direction>0)
  84.    {
  85.     printf("\n");
  86.    }
  87.   }
  88.  }
  89. }
  90.  
  91. void Serial_CloseAll(void)
  92. {
  93.  if (MoniteurActif)
  94.   printf("Fermeture du port série\n");
  95.  if (SerialInitOk)
  96.   CloseDevice((struct IORequest *)SerialIO);
  97.  if (IncomingIO)
  98.   DeleteExtIO((struct IORequest *)IncomingIO);
  99.  if (SerialIO)
  100.   DeleteExtIO((struct IORequest *)SerialIO);
  101.  if (SerialMP)
  102.   DeletePort(SerialMP);
  103. }
  104.  
  105. void Appli_CloseAll(void)
  106. {
  107.  Serial_CloseAll();
  108.  #ifdef GENERATE_GUI
  109.  if (App)
  110.  {
  111.   DisposeApp(App);
  112.   App=NULL;
  113.   CloseLibrary(MUIMasterBase);
  114.  }
  115.  #endif
  116.  Mem_FreeAll();
  117. }
  118.  
  119. void Serial_OpenAll(void)
  120. { 
  121.  int Erreur;
  122.  char MessageErreur[255];
  123.  if (MoniteurActif)
  124.   printf("Ouverture du port série\n");
  125.  SerialInitOk = FALSE;
  126.  if ((SerialMP = (struct MsgPort *) CreatePort(0, 0)) == NULL)
  127.  {
  128.   ErrorMessageRequest("Can't create message port");
  129.   Serial_CloseAll();
  130.  }
  131.  else
  132.  {
  133.   if ((SerialIO = (struct IOExtSer *) CreateExtIO(SerialMP, sizeof(struct IOExtSer))) == NULL)
  134.   {
  135.    ErrorMessageRequest("Can't allocate storage for ExtIO");
  136.    Serial_CloseAll();
  137.   }
  138.   else
  139.   {
  140.    if ((IncomingIO = (struct IOExtSer *) CreateExtIO(SerialMP, sizeof(struct IOExtSer))) == NULL)
  141.    {
  142.     ErrorMessageRequest("Can't allocate storage for ExtIO");
  143.     Serial_CloseAll();
  144.    }
  145.    else
  146.    {
  147.     Erreur=OpenDevice(SerialDevice, (long) SerialUnit, (struct IORequest *) SerialIO, 0L);
  148.     if (Erreur!=0)
  149.     {
  150.      sprintf(MessageErreur,"Can't open device '%s',unit:%d",SerialDevice,SerialUnit);
  151.      ErrorMessageRequest(MessageErreur);
  152.      Serial_CloseAll();
  153.     }
  154.     else
  155.     {
  156.      SerialInitOk=TRUE;
  157.      SerialIO->io_SerFlags = SERF_SHARED|SERF_PARTY_ON;
  158.      SerialIO->io_ReadLen=7;
  159.      SerialIO->io_WriteLen=7;
  160.      SerialIO->io_StopBits=1;
  161.      SerialIO->io_Baud=SerialSpeed;
  162.      SerialIO->IOSer.io_Command = SDCMD_SETPARAMS;
  163.      if (DoIO((struct IORequest *)SerialIO) != NULL)
  164.      {
  165.       ErrorMessageRequest("Unable to set serial params");
  166.       Serial_CloseAll();
  167.      }
  168.      else
  169.      {
  170.       memcpy(IncomingIO, SerialIO, sizeof(struct IOExtSer));
  171.      }
  172.     }
  173.    }
  174.   }
  175.  }
  176. }
  177.  
  178. void Serial_Write(struct IOExtSer *Ser_IO, char *Data,int Lgt)
  179. {
  180.  int ErrorNbr;
  181.  char MessageErreur[255];
  182.  Ser_IO->IOSer.io_Command = CMD_WRITE;
  183.  Ser_IO->IOSer.io_Length = Lgt;
  184.  Ser_IO->IOSer.io_Data = (APTR) Data;
  185.  ErrorNbr=DoIO((struct IORequest *)Ser_IO);
  186.  if (ErrorNbr != NULL)
  187.  {
  188.   sprintf(MessageErreur,"Serial write failed, error:%d",ErrorNbr);
  189.   ErrorMessageRequest(MessageErreur);
  190.   Appli_CloseAll();
  191.   exit(30);
  192.  }
  193.  if (MoniteurActif)
  194.  {
  195.   Print_Monitor(Data,Lgt,MoniteurMode,MONITOR_OUT);
  196.  }
  197. }
  198.  
  199. int Serial_Read(struct IOExtSer *Ser_IO, APTR Data)
  200. {
  201.  int length;
  202.  int ErrorNbr;
  203.  char MessageErreur[255];
  204.  IncomingIO->IOSer.io_Command = SDCMD_QUERY;
  205.  IncomingIO->IOSer.io_Actual = 0;
  206.  if (DoIO((struct IORequest *)IncomingIO) != NULL)
  207.  {
  208.   ErrorMessageRequest("Serial SDCMD_QUERY failed");
  209.   Appli_CloseAll();
  210.   exit(30);
  211.   }
  212.   if ((length = IncomingIO->IOSer.io_Actual) > 0)
  213.   {
  214.    IncomingIO->IOSer.io_Command = CMD_READ;
  215.    IncomingIO->IOSer.io_Length = length;
  216.    IncomingIO->IOSer.io_Data = Data;
  217.    ErrorNbr=DoIO((struct IORequest *)IncomingIO);
  218.    if ( ErrorNbr!= NULL)
  219.    {
  220.     /* Erreur de parité ? */
  221.     if ( (ErrorNbr==SerErr_ParityErr) || (ErrorNbr==SerErr_BufOverflow) )
  222.     {
  223.      length=0;
  224.     }
  225.     else
  226.     {
  227.      sprintf(MessageErreur,"Serial read failed, error:%d",ErrorNbr);
  228.      ErrorMessageRequest(MessageErreur);
  229.      Appli_CloseAll();
  230.      exit(30);
  231.     }
  232.    }
  233.    return length;
  234.  }
  235. }
  236.  
  237. /* Get number of seconds from clock */
  238. ULONG get_timer_secs(void)
  239. {
  240.   unsigned long secondes;
  241.   unsigned long microsecs;
  242.   CurrentTime(&secondes,µsecs);
  243.   return secondes;
  244. }
  245.  
  246.  
  247. /* Making the complete frame when calling this function many times
  248.    Back: "TRUE" if frame is complete.
  249.    --------------------------------------------------------------
  250.    DetecEOT      : caractere to indicate the end of the frame
  251.    MemoStartTime : pointer on the start time (Back: write NULL if 'TimeOut' detected)
  252.    Data          : pointer on the string to complete
  253.    NbrCarac      : pointer on the number of caracters of the string received actually
  254.    TimeOut       : nbr of seconds maxi before end of frame
  255. */
  256. int Serial_StringCompose(char DetecEOT,char *Data,int *NbrCarac,unsigned long *MemoStartTime,int TimeOut)
  257. {
  258.  char DataTemp[5000];
  259.  int NbrCaracTemp;
  260.  char EOTfound=FALSE; 
  261.  /* Récupération de la trame au fur et à mesure (fonction non-bloquante) */
  262.  NbrCaracTemp=Serial_Read(SerialIO,DataTemp);
  263.  if (NbrCaracTemp>0)
  264.  {
  265.   strcpy_limited(Data+*NbrCarac,DataTemp,NbrCaracTemp);
  266.   *NbrCarac=*NbrCarac+NbrCaracTemp;
  267.   /* Détection de la fin de trame */
  268.   if (Data[(*NbrCarac)-1]==DetecEOT)
  269.   {
  270.    if (MoniteurActif)
  271.    {
  272.     Print_Monitor(Data,*NbrCarac,MoniteurMode,MONITOR_IN);
  273.    }
  274.    EOTfound=TRUE;
  275.   }
  276.  }
  277.  /* Verifying the Time-Out if used */
  278.  if (MemoStartTime!=NULL)
  279.  {
  280.   if ((get_timer_secs()-*MemoStartTime)>TimeOut)
  281.   {
  282.    *MemoStartTime=NULL;
  283.    if (MoniteurActif)
  284.     printf("Erreur:TimeOut in StringCompose!\n");
  285.   }
  286.  }
  287.  return EOTfound;
  288. }
  289.  
  290. /* ############################### */
  291. /* # Initialization of the modem # */
  292. /* ############################### */
  293. int init_modem(char *InitString)
  294. {
  295.  int InitOk=FALSE;
  296.  char TrameToModem[64];
  297.  char TrameFmModem[256];
  298.  int LgtTrameFmModem;
  299.  int TrameComplete;
  300.  unsigned long MemoTime;
  301.  int nbratt;
  302.  /* Send standart string 'ATZ' */
  303.  strcpy(TrameToModem,"ATZ\r");
  304.  Serial_Write(SerialIO,TrameToModem,4);
  305.  MemoTime=get_timer_secs();
  306.  nbratt=3;
  307.  do
  308.  {
  309.   LgtTrameFmModem=0;
  310.   do
  311.   {
  312.    TrameComplete=Serial_StringCompose(10,TrameFmModem,&LgtTrameFmModem,&MemoTime,5);
  313.    Delay(5);
  314.   }
  315.   while ((TrameComplete!=TRUE)&&(MemoTime!=NULL));
  316.   if (MemoTime!=NULL)
  317.   {
  318.    if (str_pos(TrameFmModem,LgtTrameFmModem,"OK",2)==NULL)
  319.    {
  320.     nbratt--;
  321.    }
  322.    else
  323.    {
  324.     InitOk=TRUE;
  325.    }
  326.   }
  327.  }
  328.  while((InitOk!=TRUE)&&(MemoTime!=NULL)&&(nbratt>0));
  329.  
  330.  /* Send configuration string */
  331.  if ( (InitOk)&&(strlen(InitString)>0) )
  332.  {
  333.   InitOk=FALSE;
  334.   strcpy(TrameToModem,InitString);
  335.   strcpy(TrameToModem+strlen(InitString),"\r");
  336.   Serial_Write(SerialIO,TrameToModem,strlen(InitString)+1);
  337.   MemoTime=get_timer_secs();
  338.   nbratt=3;
  339.   do
  340.   {
  341.    LgtTrameFmModem=0;
  342.    do
  343.    {
  344.     TrameComplete=Serial_StringCompose(10,TrameFmModem,&LgtTrameFmModem,&MemoTime,5);
  345.     Delay(5);
  346.    }
  347.    while ((TrameComplete!=TRUE)&&(MemoTime!=NULL));
  348.    if (MemoTime!=NULL)
  349.    {
  350.     if (str_pos(TrameFmModem,LgtTrameFmModem,"OK",2)==NULL)
  351.     {
  352.      nbratt--;
  353.     }
  354.     else
  355.     {
  356.      InitOk=TRUE;
  357.     }
  358.    }
  359.   }while((InitOk!=TRUE)&&(MemoTime!=NULL)&&(nbratt>0));
  360.  }
  361.  return InitOk;
  362. } 
  363.  
  364. /* ################################################# */
  365. /* # Calling and waiting connection with the modem # */
  366. /* # Return : FALSE => under call                  # */
  367. /* #          TRUE => call succesfull              # */
  368. /* #          2 => Error 'TIME-OUT !'              # */
  369. /* #          3 => Error 'BUSY'                    # */
  370. /* ################################################# */
  371. int call_modem(char *NumTel,int FirstCall)
  372. {
  373.  int ConnectOk=FALSE;
  374.  char TrameToModem[64];
  375.  static char TrameFmModem[256];
  376.  static int LgtTrameFmModem;
  377.  static unsigned long MemoTime;
  378.  int TrameComplete;
  379.  char * StringConnected;
  380.  static char StringMessageSpeed[64];
  381.  
  382.  /* CALLING THE TELEPHONE NUMBER WITH ATDTxxxxxxx */
  383.  if (FirstCall)
  384.  {
  385.   strcpy(TrameToModem,"ATDT");
  386.   strcpy(TrameToModem+4,NumTel);
  387.   strcpy(TrameToModem+4+strlen(NumTel),"\r");
  388.   Serial_Write(SerialIO,TrameToModem,strlen(TrameToModem));
  389.   MemoTime=get_timer_secs();
  390.   LgtTrameFmModem=0;
  391.  }
  392.  /* WAITING MESSAGE "CONNECT" FROM MODEM */
  393.  TrameComplete=Serial_StringCompose(10,TrameFmModem,&LgtTrameFmModem,&MemoTime,50);
  394.  if (TrameComplete)
  395.  {
  396.   StringConnected=str_pos(TrameFmModem,LgtTrameFmModem,"CONNECT",7);
  397.   if (StringConnected!=NULL)
  398.   {
  399.    ConnectOk=TRUE;
  400.    strcpy(StringMessageSpeed,"Connecté à: ");
  401.    strcpy_termnotnull(StringMessageSpeed+strlen(StringMessageSpeed),StringConnected+8,13,10);
  402.    DisplayStatus(StringMessageSpeed);
  403.   }
  404.   StringConnected=str_pos(TrameFmModem,LgtTrameFmModem,"BUSY",4);
  405.   if (StringConnected!=NULL)
  406.   {
  407.    ConnectOk=3;
  408.   }
  409.   LgtTrameFmModem=0;
  410.  }
  411.  if (MemoTime==NULL)
  412.   ConnectOk=2;
  413.  return ConnectOk;
  414. }
  415.  
  416. /* ################################################# */
  417. /* # Hanging up the actual connection of the modem # */
  418. /* ################################################# */
  419. void hangup_modem(void)
  420. {
  421.  int i;
  422.  Delay(100);
  423.  Serial_Write(SerialIO,"+++",3);
  424.  Delay(10);
  425.  i=Serial_Read(SerialIO,TrameRecue);
  426.  Delay(150);
  427.  Serial_Write(SerialIO,"ATH0\r",5);
  428.  Delay(10);
  429.  i=Serial_Read(SerialIO,TrameRecue);
  430.  Delay(25);
  431.  Serial_Write(SerialIO,"ATZ\r",4);
  432.  Delay(10);
  433.  i=Serial_Read(SerialIO,TrameRecue);
  434.  Delay(25);
  435.  i=Serial_Read(SerialIO,TrameRecue);
  436. if (MoniteurActif)
  437. printf("-----%d\n",i);
  438. }
  439.